package pe.gob.foncodes.ssa.web.controller;


import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.logging.Level;
import javax.faces.bean.ManagedBean;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.servlet.http.HttpSession;
import org.apache.log4j.Logger;
import org.primefaces.context.RequestContext;
import org.primefaces.model.TreeNode;
import org.primefaces.model.DualListModel;
import pe.gob.foncodes.ssa.bs.administracion.controller.GenericMaintenanceController;
import pe.gob.foncodes.ssa.bs.common.util.Constante;
import pe.gob.foncodes.ssa.bs.common.util.DateHelper;
import pe.gob.foncodes.ssa.bs.common.util.Encriptador;
import pe.gob.foncodes.ssa.bs.common.util.PasswordHelper;
import pe.gob.foncodes.ssa.bs.common.util.ServiceException;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Usuario;
import org.primefaces.model.DefaultTreeNode;
import pe.gob.foncodes.ssa.bs.common.util.StringHelper;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Accion;
import pe.gob.foncodes.ssa.bs.seguridad.domain.ControlAcceso;
import pe.gob.foncodes.ssa.bs.seguridad.domain.General;
import pe.gob.foncodes.ssa.bs.seguridad.domain.HorarioPerfil;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Modulo;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Opcion;
import pe.gob.foncodes.ssa.bs.seguridad.domain.SeguridadAdicional;
import pe.gob.foncodes.ssa.bs.seguridad.domain.UsuarioPerfil;
import pe.gob.foncodes.ssa.bs.seguridad.service.UsuarioService;
import pe.gob.foncodes.ssa.web.util.Utilitarios;

@ManagedBean(name = "loginController")
public class LoginController extends GenericMaintenanceController {

    protected static Logger log = Logger.getLogger(LoginController.class);
    private String newPassword;
    private String verifyPassword;
    private Date logDate = DateHelper.getFechaActual();
    private DecimalFormat formatoDecimal = new DecimalFormat("####.#");
    private int intento;
    private UsuarioService usuarioService;
    private boolean bMuestraCaptcha;
    private boolean muestraBloqueo;
    private boolean registraAcesso;
    private boolean logueado= false;
    private String mensaje;
    
    //Pregunta Secreta
    private List<General> preguntas = new ArrayList<General>();
    private String SPreguntaSecreta;
    private String SRespuestaSecreta;
    
    //Pantallas
    private String sTerritorial = "";
    private Date fecha;
    private boolean bContactoAdmin=false;
    
    List<Usuario> lstUsuarios = new ArrayList <Usuario>();
    Usuario selectedUsuario= new Usuario();
    private TreeNode root;  
    
    private DualListModel<String> perfiles;
    
    private HashMap<String, List<Accion>> menuBar = new HashMap<String, List<Accion>>();
    
    @Override
    public void init() {
        setNewPassword("");
        setVerifyPassword("");
        if (((Usuario) getBean()).getFecCambioClave() == null) {
            ((Usuario) getBean()).setFecCambioClave(Constante.FECHA_INICIO);
        }
        mensaje = "";
        inicio();
    }

    
    public void inicio(){
        log.info(">>>>>>>> inicio");
        bContactoAdmin = false;
        fecha = new Date();
        root = new DefaultTreeNode("root", null);
        TreeNode inicial = new DefaultTreeNode("Sistema Integrado - FONCODES", root);  
        inicial.setExpanded(true);
        TreeNode documents = new DefaultTreeNode("Sistema de Gestion Administrativa", inicial);
        TreeNode gestion = new DefaultTreeNode("Sistema de Gestion de Proyectos", inicial);
        gestion.setExpanded(true);
        TreeNode movies = new DefaultTreeNode("Sistema de Informacion Ejecutiva", inicial);
        TreeNode movies2 = new DefaultTreeNode("Sistema de Seguridad y Auditoria de Informacion", inicial);
        TreeNode movies3 = new DefaultTreeNode("Sistema para el monitoreo y Evaluacion", inicial);
        TreeNode movies4 = new DefaultTreeNode("Sistema de Informacion via web", inicial);
        
        TreeNode work = new DefaultTreeNode("Alerta SGP", gestion);  
        TreeNode antiguos = new DefaultTreeNode("Modulo de Antiguos", gestion);
        antiguos.setExpanded(true);
        TreeNode work2 = new DefaultTreeNode("Modulo de Compras", gestion);  
        TreeNode work3 = new DefaultTreeNode("Modulo de Formatos", gestion);  
        TreeNode work4 = new DefaultTreeNode("Modulo de Liquidaciones y Transferencias", gestion);  
        TreeNode work5 = new DefaultTreeNode("Sistema de Procesos Legales", gestion);  
        TreeNode work6 = new DefaultTreeNode("Sistema de Tramites de Proyectos", gestion);  
        
        //Documents  
        TreeNode expenses = new DefaultTreeNode("Modulo de Actualizacion", antiguos);  
        expenses.setExpanded(true);
        TreeNode resume = new DefaultTreeNode("Modulo Evaluacion y Monitoreo", antiguos);  
        TreeNode refdoc = new DefaultTreeNode("Modulo de PMASB", antiguos);  
        
        
        //Cities  
        List<String> perfilesSource = new ArrayList<String>();  
        List<String> perfilesTarget = new ArrayList<String>();  
          
        perfilesSource.add("Administrador del sistema");  
        perfilesSource.add("Asesor Legal / Zonal");  
        perfilesSource.add("Seguimiento o Procesos");  
        perfilesSource.add("Prueba");  
        perfilesSource.add("Perfil 5");  
        perfilesSource.add("Perfil 6");  
          
        perfiles = new DualListModel<String>(perfilesSource, perfilesTarget);
    }
    
    public boolean validatePass() {
        boolean success = true;
        if(getNewPassword() == null) setNewPassword("");
        if(getVerifyPassword() == null) setVerifyPassword("");
        if (getNewPassword().equals("") || !(getNewPassword().length() > 7)) {
            success = false;
            setMessageError("Debe ingresar correctamente la nueva contraseña.");
            return success;
        }
        if (getVerifyPassword().equals("") || !(getVerifyPassword().length() > 7)) {
            success = false;
            setMessageError("Debe ingresar correctamente la confirmación de la contraseña.");
            return success;
        }
        return success;
    }

    public void changePassword() throws Exception {
        if (validatePass()) {
            Usuario miUsr = ((Usuario) getBeanBusqueda());
            log.info("clave se="+((Usuario)getSession(true).getAttribute(Constante.SESSION_USER)).getTxtClave());
            log.info("clave be="+((Usuario)getBean()).getTxtClave());
            //setBeanBusqueda(new Usuario());
            double tiempoEsperaCambioPass = Double.valueOf(((General) getService().findGeneralByCode(General.class, Constante.TIEMPO_ESPERA_CAMBIO_PASS_DIAS)).getTxtValor());
            int maximoPassAlamcenados = Integer.valueOf(((General)getService().findGeneralByCode(General.class, Constante.MAXIMOS_PASSWORDS_ALMACENADOS)).getTxtValor());
            //Verifico Fecha del ultimo cambio de contrasenia
            if (DateHelper.fechasDiferenciaEnDias(logDate, miUsr.getFecCambioClave()) <= tiempoEsperaCambioPass) {
                setMessageError(new Exception("Debe esperar un plazo mnimo de " + formatoDecimal.format(tiempoEsperaCambioPass * 24) + " hora(s) para poder cambiar su contraseña."));
            } else {
                if (newPassword.equals(verifyPassword)) {
                    String claveFinal = getUsuarioService().retornaClaveEncriptada(newPassword, miUsr.getCodUsuario());
                    if (PasswordHelper.controlPass(miUsr.getTxtClave(), newPassword, miUsr.getCodUsuario(), claveFinal)) {
                        log.info("Start of Transaction: 'Change Password' at " + DateHelper.getFechaActual());
                        log.info("User initiating transaction" + miUsr.getCodUsuario());
                        log.info("clave="+((Usuario)getSpringBean(Constante.SESSION_USER)).getTxtClave());
                        String miPassword = "";
                        newPassword = claveFinal;
                        miPassword = newPassword + Constante.SEPARADOR_CONTRASENIA + ((Usuario)getBean()).getTxtClave();
                        miUsr.setTxtClave(PasswordHelper.listaPassword(miPassword, maximoPassAlamcenados));
                        miUsr.setFecCambioClave(DateHelper.getFechaActual());
                        miUsr.setFlgCaducidadClave(Constante.CLAVE_NO_CADUCADA);
                        setBean(miUsr);
                        try {
                            RequestContext context = RequestContext.getCurrentInstance();
                            getService().save(getBean());
                            mensaje = "Su contraseña ha sido cambiada de manera exitosa";
                            context.execute("wCambioClave.hide()");
                            context.execute("wCambioClaveOK.show()");
                            log.info("End of Transaction: 'Change Password'");
                        } catch (Exception e) {
                            log.error(e.getMessage());
                            setMessageError(e);
                        }
                    } else {
                        setMessageError(new Exception(PasswordHelper.mensaje));
                    }
                } else {
                    setMessageError(new Exception("La nueva contraseña y repita su nueva contraseña son diferentes. Por favor, asegúrese que sean iguales."));
                }
            }
        }
    }

    public String closeSession() {
        log.info("Closed Session of " + ((Usuario) getSpringBean(Constante.SESSION_USER)).getCodUsuario() + " at " + DateHelper.getFechaActual());
        getSession(false).setAttribute(Constante.SESSION_USER, null);
        getSession(false).invalidate();
        return "login";
    }
    
    public void cancelar(){
        log.info("muestraCaptcha inicio="+isbMuestraCaptcha());
        bMuestraCaptcha = true;
        setBeanBusqueda(new Usuario());
        log.info("muestraCaptcha fin   ="+isbMuestraCaptcha());
    }
    
    public void limpiaCambioClave() {
        this.newPassword = "";
        this.verifyPassword = "";
    }
    
    public void limpiaClaveUsuario(){
        Usuario usuario = (Usuario) getBeanBusqueda();
        usuario.setTxtClave("");
        setBeanBusqueda(usuario);
        limpiaCambioClave();
    }
    
    public String login2() throws Exception{
        String redirectTo = "login";
        bMuestraCaptcha = false;
        muestraBloqueo = false;
        registraAcesso = false;
        logueado= false;
        Usuario usuario = (Usuario) getBeanBusqueda();
        String claveAntigua = usuario.getTxtClave();
        Date fechaActual = Constante.FECHA_ACTUAL;
        
        if (usuario.getCodUsuario() == null) {
            Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Por favor ingresa tu codigo de usuario");
            return redirectTo;
        }
        if (usuario.getTxtClave() == null) {
            Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Por favor ingresa tu contraseña");
            return redirectTo;
        }
        
        //Cargando parametros del Sistema para el Login
        Long maximoNroIntentosLogin = Long.valueOf(((General)getService().findGeneralByCode(General.class, "MAXIMO_NRO_INTENTOS_LOGIN")).getTxtValor());
        Long maximoTiempoSinCambioPass = Long.valueOf(((General)getService().findGeneralByCode(General.class, "MAXIMO_TIEMPO_SIN_CAMBIO_PASS")).getTxtValor());
        
        if (usuario.getCodUsuario() != null) {
            usuario.setCodUsuario(usuario.getCodUsuario().toUpperCase().trim());
            String enc_clave =  usuario.getTxtClave();
            //llamar a funcion de clave
            enc_clave = getUsuarioService().retornaClaveEncriptada(enc_clave, usuario.getCodUsuario());
            log.info("Clave Encriptada: " + enc_clave);
            usuario.setTxtClave(enc_clave);
        }
        Usuario user = null;
        user = (Usuario) getService().findByCode(Usuario.class, usuario.getCodUsuario().trim());
        log.info(">>>>>>> clave INICIAL 0="+user.getTxtClave());
        
        if(user == null){
            Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Usuario no registrado");
            setBeanBusqueda(new Usuario());
        }else{
            RequestContext context = RequestContext.getCurrentInstance();
            FacesContext facesContext = FacesContext.getCurrentInstance();
            HttpSession session = (HttpSession) facesContext.getExternalContext().getSession(true);
            session.setAttribute(Constante.SESSION_USER, user);
            setBean(user);
            
            ControlAccesoController controlAccesoController = (ControlAccesoController)getSpringBean("controlAccesoController");
            controlAccesoController.load();
                        
            //Obtiene el ultimo ingreso del usuario
            Date ultimo_ingreso=controlAccesoController.getUltimoIngreso();
            
            ControlAcceso loginLog = new ControlAcceso();
            loginLog.setNidUsuario(user);
            loginLog.setCodZonal(user.getCodZonal());
            loginLog.setTxtSessionid(session.getId());
            loginLog.setNidModulo((Modulo)getService().findById(Modulo.class, Constante.NID_MODULO_SSA));
            
            if (StringHelper.miCad(user.getTxtClave(),",").equals(usuario.getTxtClave())) {
                
                if (user.getFlgActivo().equals(Constante.ESTADO_INACTIVO)){
                    Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Usuario no se encuentra activo");
                    return redirectTo;
                }
                
                if (user.getFlgBloqueado().equals(Constante.ESTADO_BLOQUEADO)){
                    Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Usuario bloqueado");
                    muestraBloqueo = true;
                    return redirectTo;
                }
                
                //Abrir el dialog de
                if(user.getFlgCaducidadClave().equals(Constante.CLAVE_CADUCADA)){
                    mensaje = "La contraseña ha caducado";
                    context.execute("wClaveCaduca.show()");
                    log.info(">>>>>>> clave INICIAL 1="+user.getTxtClave());
                    user.setTxtClave(claveAntigua);
                    log.info(">>>>>>> clave INICIAL 2="+user.getTxtClave());
                    setBeanBusqueda(user);
                    return redirectTo;
                }
                
                List<UsuarioPerfil> usuarioPerfilList = getService().findByNamedQuery("UsuarioPerfil.findByNidUsuarioAndFlgActivo", new Object[]{user.getId(), Constante.ESTADO_ACTIVO});
                List<HorarioPerfil> horarioPerfil=getUsuarioService().retornaHorarioPorPerfiles(usuarioPerfilList, Constante.ESTADO_ACTIVO);
                
                if(!horarioPerfil.isEmpty()){
                    boolean bvalidaHorario = false;
                    for (HorarioPerfil hp : horarioPerfil) {
                        if(fechaActual.after(hp.getFecHoraInicio()) && fechaActual.before(hp.getFecHoraFin())){
                            bvalidaHorario = true;
                            break;
                        }
                    }
                    if(!bvalidaHorario){
                        Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "El usuario no se encuentra dentro del horario de acceso permitido");
                        return redirectTo;
                    }
                }
                
                loginLog.setFecRegistro(Constante.FECHA_ACTUAL);
                loginLog.setFlgAcceso(Constante.INTENTO_VALIDO);
                getService().save(loginLog);
                try {
                    menuBar = new HashMap<String, List<Accion>>();
                    List<Opcion> firstLevelNodes = getUsuarioService().getFirstLevelNodes(user.getId(), usuarioPerfilList);
                    log.info("user.getUsuarioPerfilList() =" + usuarioPerfilList);
                    log.info("firstLevelNodes =" + firstLevelNodes);
                    for (Opcion opcion : firstLevelNodes) {
                        if (!menuBar.containsKey(opcion.getTxtOpcion())) {
                            menuBar.put(opcion.getTxtOpcion(), new ArrayList<Accion>());
                            crearMenu(opcion, menuBar, user.getId(), usuarioPerfilList);
                        }
                    }
                    log.info(menuBar.size());
                    redirectTo = "home";
                } catch (ServiceException ex) {
                    log.error(ex);
                }
            } else {
                registraAcesso = true;
                setBean(new Usuario());
                usuario.setTxtClave(claveAntigua);
                setBeanBusqueda(usuario);
                Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Su contraseña es incorrecta");
                
            }
            if(registraAcesso){
                loginLog.setFecRegistro(Constante.FECHA_ACTUAL);
                loginLog.setFlgAcceso(Constante.INTENTO_RECHAZADO);
                getService().save(loginLog);
            }
        }
        log.info("muestraCaptcha="+isbMuestraCaptcha());
        return redirectTo;
    }
    
    public void crearMenu(Opcion opcionPadre, HashMap<String, List<Accion>> menuBar, Long idUsuario, List<UsuarioPerfil> usuarioPerfilList) throws ServiceException{
        log.info("opcionPadre="+opcionPadre.getTxtOpcion());
        List<Accion> acciones = getUsuarioService().getOtherLevelNodes(opcionPadre.getId(), idUsuario, usuarioPerfilList);
        for (Accion ac : acciones) {
            if (menuBar.containsKey(opcionPadre.getTxtOpcion())) {
                menuBar.get(opcionPadre.getTxtOpcion()).add(ac);
                //menuBar.put(op.getTxtOpcion(), new ArrayList<Accion>());
                crearMenu(ac.getNidOpcion(), menuBar, idUsuario, usuarioPerfilList);
            }
        }
    }
    
    public void validaConfirmacionIdentidad(){
    }
    
    public void loadPreguntasSecretas(){
        SPreguntaSecreta = "-1";
        SRespuestaSecreta = "";
        try {
            preguntas = getService().findByNamedQuery("General.findByTxtDominioEstado", new Object[]{Constante.DOMINIO_PREGUNTA_SECRETA, Constante.ESTADO_ACTIVO});
        } catch (ServiceException e) {
            log.error("ERROR EN loadPreguntasSecretas: "+e);
        }
    }
    
    public void actualizaPreguntaSecreta(){
        if(SRespuestaSecreta == null) SRespuestaSecreta ="";
        if(SRespuestaSecreta.equals("")){
            Utilitarios.mostrarMensajeError(null, "Error en actualizar pregunta secreta", "Ingrese la respuesta");
            return;
        }
        Usuario miUsr = ((Usuario) getBean());
        List<SeguridadAdicional> lista = new ArrayList<SeguridadAdicional>();
        try {
            lista = getService().findByNamedQuery("SeguridadAdicional.findByNIdUsuarioAndEstado", new Object[]{miUsr.getId(), Constante.ESTADO_ACTIVO});
        } catch (ServiceException e) {
            log.error("ERROR EN actualizaPreguntaSecreta: " + e);
        }
        boolean bRespuestaValida = false;
        for (SeguridadAdicional sa : lista) {
            log.info("sa.getTxtRespuesta()="+sa.getTxtRespuesta());
            if(sa.getTxtRespuesta().trim().equals(SRespuestaSecreta.trim())){
                bRespuestaValida = true;
                break;
            }
        }
        if(bRespuestaValida){
            RequestContext context = RequestContext.getCurrentInstance();
            mensaje = "Su pregunta secreta se ha actualizado correctamente";
            context.execute("wCambioPreguntaSecreta.hide()");
            context.execute("wCambioPreguntaSecretaOK.show()");
        }else{
            Utilitarios.mostrarMensajeError(null, "Error en actualizar pregunta secreta", "La respuesta no es la correcta");
        }
    }
    
    public String login() throws Exception {
        log.info("Start of Transaction: 'Login' at " + DateHelper.getFechaActual());
        return "";
        /*
        String redirectTo = "login";
        boolean galf = false;
        List<Usuario> usuarios = null;
        Usuario Usuario = new Usuario();
        Usuario.setCodUsuario(getUsuario());
        Usuario.setTxtClave(getClave());
        setBeanBusqueda(Usuario);
        String localHost = String.valueOf(InetAddress.getLocalHost());

        //Cargando parametros del Sistema para el Login
        Long maximoTiempoInactividad = Long.valueOf(((Parametro) getService().findByCode(Parametro.class, "MAXIMO_TIEMPO_INACTIVIDAD")).getValor());
        Long maximoTiempoSinCambioPass = Long.valueOf(((Parametro) getService().findByCode(Parametro.class, "MAXIMO_TIEMPO_SIN_CAMBIO_PASS")).getValor());
        double tiempoEsperaReactivacion = Double.valueOf(((Parametro) getService().findByCode(Parametro.class, "TIEMPO_ESPERA_REACTIVACION_DIAS")).getValor());
        Long maximoIntentosLogin = Long.valueOf(((Parametro) getService().findByCode(Parametro.class, "MAXIMO_NRO_INTENTOS_LOGIN")).getValor());

        if (Usuario.getCodUsuario() != null) {
            log.info("UserName :" + Usuario.getCodDni().trim());
            String enc_clave = Usuario.getTxtClave();
            enc_clave = Encriptador.encryptBlowfish(enc_clave, Constante.KEY);
            log.info("Clave : " + enc_clave);
            Usuario.setTxtClave(enc_clave);
            Usuario.setCodUsuario(Usuario.getCodUsuario().toUpperCase().trim());
        }

        Usuario usr = (Usuario) getService().findByCode(Usuario.class, Usuario.getCodUsuario().trim());

        //Si existe el usuario
        if (usr != null) {

//            LoginLogController loginLogController = (LoginLogController) getSpringBean("loginLogController");
//            List<LoginLog> listTmp = null;
//            LoginLog tmp = new LoginLog();
//            LoginLog ll = new LoginLog();
//            ll.setUsuarioID(usr.getNidUsuario());
//            ll.setFechaCreacion(DateHelper.getFechaActual());
//            //ll.setIp(StringHelper.dameMiIp(localHost));
//            ll.setIp(localHost);
//            ll.setHost(StringHelper.dameMiHost(localHost));
//
//            usuarios = getService().findByObject(usr);
//            tmp.setUsuarioID(usr.getId());
//
//            //Obtiene la lista de los ingresos del usuario (Modificar)
//            listTmp = getService().findByObject(tmp);
//            Date ultimo_ingreso = loginLogController.ultimoIngreso(listTmp, Constante.INTENTO_VALIDO);
            //Date ultimo_ingreso=new Date();

            //Se valida que el usuario y la contrasea sean validos

            if (StringHelper.miCad(usr.getTxtClave(), ",").equals(Usuario.getTxtClave())) {

                setBean(usuarios.get(0));
                Usuario usuarioEnSesion = (Usuario) getSpringBean(Constante.SESSION_USER);
                PropertyUtils.copyProperties(usuarioEnSesion, (Usuario) usuarios.get(0));
                //loginLogController.load();

                //Date fail=loginLogController.ultimoIngreso(listTmp, Constante.INTENTO_RECHAZADO);

                //Se verifica si ha sido bloqueado por login fallido y se activa pasado los 30 min
                if (usr.getFlgActivo().equals(Constante.ESTADO_INACTIVO)) {
                    setMessageError("El usuario esta deshabilitado. Contctese con el administrador");
                    return "login";
                }

                if ((usr.getEstado().equals(Constante.ESTADO_BLOQUEADO)) && (DateHelper.fechasDiferenciaEnDias(DateHelper.getFechaActual(), usr.getFechaModificacion()) >= tiempoEsperaReactivacion)) {
                    try {
                        usr.setEstado(Constante.ESTADO_HABILITADO);
                        getService().save(usr);
                        usuarios.get(0).setEstado(Constante.ESTADO_HABILITADO);
                        getService().saveCollection(usuarios);
                        log.info("Actualizacion de Estado del Usuario - Correcta");
                    } catch (Exception e) {
                        log.error(e.getMessage());
                        setMessageError(e);
                    }
                } else {

                    if ((usr.getEstado().equals(Constante.ESTADO_BLOQUEADO)) && (DateHelper.fechasDiferenciaEnDias(DateHelper.getFechaActual(), usr.getFechaModificacion()) < tiempoEsperaReactivacion)) {
                        setMessageError("Se ha bloqueado al usuario durante " + formatoDecimalMin.format(tiempoEsperaReactivacion * 24 * 60) + " minutos.");
                        return "login";
                    }
                }

                //Se redirecciona para usuario nuevos
                if (usuarios.get(0).getFechaCambioPass() != null && !usuarios.get(0).getEstado().equals(Constante.ESTADO_NUEVO)) {

                    //No se permite el ingreso de usuarios Bloqueados

                    if (!usuarios.get(0).getEstado().equals(Constante.ESTADO_BLOQUEADO)) {


                        //Bloquear al usuario si no esta activo por mas de 90 dias		

                        if (((int) DateHelper.fechasDiferenciaEnDias(logDate, ultimo_ingreso) <= maximoTiempoInactividad) || ((int) DateHelper.fechasDiferenciaEnDias(logDate, usuarios.get(0).getFechaModificacion()) <= maximoTiempoInactividad)) {


                            //Si la contrasea no se ha cambiado en 35 dias
                            //if ((int)DateHelper.fechasDiferenciaEnDias(logDate,usuarios.get(0).getFechaCambioPass())<=maximoTiempoSinCambioPass){

                            setBeanBusqueda(new Usuario());
                            String sisOperativo = getRequest().getHeader("user-agent").toUpperCase();
                            MenuController menuController = (MenuController) getSpringBean("menuController");
                            if (sisOperativo.indexOf(Constante.SISTEMA_OPERATIVO_WIN) >= 0) {
                                menuController.setVerMenuWin(true);
                            } else {
                                menuController.setVerMenuWin(false);
                            }
                            menuController.init();

                            try {
                                //MonitoreoAlertaController monitoreoAlerta = (MonitoreoAlertaController)getSpringBean("monitoreoAlertaController");
                                //monitoreoAlerta.init();
                                //MonitoreoResumenController monitoreoResumen = (MonitoreoResumenController)getSpringBean("monitoreoResumenController");
                                //monitoreoResumen.init();
                            } catch (Exception e) {
                                log.error(e);
                            }

                            redirectTo = "bandejaMonitoreoAlerta";
                            ll.setTipoIntento(Constante.INTENTO_VALIDO);
                            try {
                                String ip = getClientIp();
                                if(usr.getCrgId()!=null){
                                if(!usr.getCrgId().getId().equals(Constante.CARGO_AGENTE_ID)){
                                getService().save(ll);
                                }
                                }
                                log.info("Login Vlido");
                                log.info("Connection established from : " + localHost);
                            } catch (Exception e) {
                                log.error(e.getMessage());
                                setMessageError(e);
                            }
                            }else{
                            
                            System.out.println("cambio");
                            setBean(usr);
                            redirectTo="cambio";
                            }
                        } else {
                            setMessageError(new Exception("El usuario esta bloqueado por inactividad. Contactese con el administrador"));
                            setBean(new Usuario());
                            try {
                                usr.setEstado(Constante.ESTADO_BLOQUEADO);
                                getService().save(usr);
                                log.info("Actualizacion de Estado del Usuario - Correcta");
                            } catch (Exception e) {
                                log.error(e.getMessage());
                                setMessageError(e);
                            }
                        }
                    } else {
                        setBean(new Usuario());
                        setMessageError(new Exception("El usuario esta bloqueado. Contactese con el administrador"));
                    }
                } else {
                    setBean(usr);
                    redirectTo = "cambio";
                }
            } else {
                intento++;
                galf = true;
                setBean(new Usuario());

                if (intento <= maximoIntentosLogin) {
                    if ((usr.getEstado().equals(Constante.ESTADO_BLOQUEADO)) && (DateHelper.fechasDiferenciaEnDias(DateHelper.getFechaActual(), usr.getFechaModificacion()) < tiempoEsperaReactivacion)) {
                        setMessageError("Se ha bloqueado al usuario durante " + formatoDecimalMin.format(tiempoEsperaReactivacion * 24 * 60) + " minutos.");
                    } else {
                        setMessageError(new Exception("La contrasea no es vlida."));
                    }
                } else {
                    setMessageError(new Exception("Se ha bloqueado al usuario durante " + formatoDecimalMin.format(tiempoEsperaReactivacion * 24 * 60) + " minutos."));
                    setBean(new Usuario());
                    try {
                        usr.setEstado(Constante.ESTADO_BLOQUEADO);
                        getService().save(usr);
                        log.info("Actualizacion de Estado del Usuario - Correcta");
                    } catch (Exception e) {
                        log.error(e.getMessage());
                        setMessageError(e);
                    }
                }
            }
            if (galf) {
                if (!(usr.getFlgActivo().equals(Constante.ESTADO_BLOQUEADO) || usr.getFlgActivo().equals(Constante.ESTADO_INACTIVO) || usr.getFlgActivo().equals(Constante.ESTADO_NUEVO) || ((int) DateHelper.fechasDiferenciaEnDias(logDate, ultimo_ingreso) > maximoTiempoInactividad))) {

                    ll.setTipoIntento(Constante.INTENTO_RECHAZADO);
                    try {
                        getService().save(ll);
                       
                        if(usr.getCrgId()!=null){
                        if(!usr.getCrgId().getId().equals(Constante.CARGO_AGENTE_ID)){
                        
                        }
                        }
                        log.info("Login Rechazado");
                    } catch (Exception e) {
                        log.error(e.getMessage());
                        setMessageError(e);
                    }
                } else {
                    setIntento(0);
                }
            }
        } else {
            setBean(new Usuario());
            setMessageError(new Exception("El usuario no existe."));
        }

        log.info("End of Transaction: 'Login'");
        //redirectTo="login";
        return redirectTo;
          */
    }

    public String getNewPassword() {
        return newPassword;
    }

    public void setNewPassword(String newPassword) {
        this.newPassword = newPassword;
    }

    public String getVerifyPassword() {
        return verifyPassword;
    }

    public void setVerifyPassword(String verifyPassword) {
        this.verifyPassword = verifyPassword;
    }

    public void setIntento(int intento) {
        this.intento = intento;
    }

    public int getIntento() {
        return intento;
    }

    public boolean isbContactoAdmin() {
        return bContactoAdmin;
    }

    public void setbContactoAdmin(boolean bContactoAdmin) {
        this.bContactoAdmin = bContactoAdmin;
    }

    public Date getFecha() {
        return fecha;
    }

    public void setFecha(Date fecha) {
        this.fecha = fecha;
    }

    public DualListModel<String> getPerfiles() {
        return perfiles;
    }

    public void setPerfiles(DualListModel<String> perfiles) {
        this.perfiles = perfiles;
    }

    public TreeNode getRoot() {
        inicio();
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }

    public String getSTerritorial() {
        return sTerritorial;
    }

    public void setSTerritorial(String sTerritorial) {
        this.sTerritorial = sTerritorial;
    }

    public Usuario getSelectedUsuario() {
        return selectedUsuario;
    }

    public void setSelectedUsuario(Usuario selectedUsuario) {
        this.selectedUsuario = selectedUsuario;
    }

    public List<Usuario> getLstUsuarios() {
        return lstUsuarios;
    }

    public void setLstUsuarios(List<Usuario> lstUsuarios) {
        this.lstUsuarios = lstUsuarios;
    }

    public UsuarioService getUsuarioService() {
        return usuarioService;
    }

    public void setUsuarioService(UsuarioService usuarioService) {
        this.usuarioService = usuarioService;
    }

    public HashMap<String, List<Accion>> getMenuBar() {
        return menuBar;
    }

    public void setMenuBar(HashMap<String, List<Accion>> menuBar) {
        this.menuBar = menuBar;
    }

    public boolean isMuestraBloqueo() {
        return muestraBloqueo;
    }

    public void setMuestraBloqueo(boolean muestraBloqueo) {
        this.muestraBloqueo = muestraBloqueo;
    }

    public boolean isbMuestraCaptcha() {
        return bMuestraCaptcha;
    }

    public void setbMuestraCaptcha(boolean bMuestraCaptcha) {
        this.bMuestraCaptcha = bMuestraCaptcha;
    }

    public boolean isRegistraAcesso() {
        return registraAcesso;
    }

    public void setRegistraAcesso(boolean registraAcesso) {
        this.registraAcesso = registraAcesso;
    }

    public String getMensaje() {
        return mensaje;
    }

    public void setMensaje(String mensaje) {
        this.mensaje = mensaje;
    }

    public String getSRespuestaSecreta() {
        return SRespuestaSecreta;
    }

    public void setSRespuestaSecreta(String SRespuestaSecreta) {
        this.SRespuestaSecreta = SRespuestaSecreta;
    }

    public List<General> getPreguntas() {
        return preguntas;
    }

    public void setPreguntas(List<General> preguntas) {
        this.preguntas = preguntas;
    }

    public String getSPreguntaSecreta() {
        return SPreguntaSecreta;
    }

    public void setSPreguntaSecreta(String SPreguntaSecreta) {
        this.SPreguntaSecreta = SPreguntaSecreta;
    }
    
}